package com.xuan.qimen.core.zhuan.shijia;

import com.nlf.calendar.EightChar;
import com.nlf.calendar.Lunar;
import com.nlf.calendar.Solar;
import com.xuan.qimen.core.fei.shijia.FeiShiJiaQiMenConstant;
import com.xuan.qimen.utils.CommonUtil;
import lombok.Getter;

import java.util.*;

/**
 * 转盘奇门（时家、拆补法）
 *
 * @author KTY
 */
//@Data
@Getter
public class ZhuanShiJiaQiMen {

    /**
     * 公历日期
     */
    private Solar solar;
    /**
     * 农历日期
     */
    private Lunar lunar;
    /**
     * 星期
     */
    private String week;

    /**
     * 年干
     */
    private String yearGan;
    /**
     * 年支
     */
    private String yearZhi;
    /**
     * 年干支
     */
    private String yearGanZhi;

    /**
     * 月干
     */
    private String monthGan;
    /**
     * 月支
     */
    private String monthZhi;
    /**
     * 月干支
     */
    private String monthGanZhi;

    /**
     * 日干
     */
    private String dayGan;
    /**
     * 日支
     */
    private String dayZhi;
    /**
     * 日干支
     */
    private String dayGanZhi;

    /**
     * 时干
     */
    private String hourGan;
    /**
     * 时支
     */
    private String hourZhi;
    /**
     * 时干支
     */
    private String hourGanZhi;

    /**
     * 八字
     */
    private List<String> baZi;
    /**
     * 八字五行
     */
    private List<String> baZiWuXing;
    /**
     * 八字旬空
     */
    private List<String> baZiXunKong;
    /**
     * 八字纳音
     */
    private List<String> baZiNaYin;

    /**
     * 符头
     */
    private String fuTou;
    /**
     * 节气
     */
    private String jieQi;
    /**
     * 三元
     */
    private String sanYuan;
    /**
     * 阴阳遁
     */
    private String yinYangDun;
    /**
     * 局数
     */
    private int juShu;
    /**
     * 旬首
     */
    private String xunShou;
    /**
     * 旬首仪仗
     */
    private String xunShouYiZhang;
    /**
     * 旬首落宫
     */
    private int xunShouGong;
    /**
     * 值符
     */
    private String zhiFu;
    /**
     * 值使
     */
    private String zhiShi;
    /**
     * 旬空
     */
    private List<String> xunKong;
    /**
     * 六甲旬空
     */
    private List<String> liuJiaXunKong;
    /**
     * 六甲旬空落宫
     */
    private List<Integer> liuJiaXunKongGong;
    /**
     * 六甲旬空落宫标识（1~9宫）
     */
    private List<String> liuJiaXunKongGongMark;
    /**
     * 驿马
     */
    private String yiMa;
    /**
     * 驿马落宫
     */
    private int yiMaGong;
    /**
     * 驿马落宫标识（1~9宫）
     */
    private List<String> yiMaGongMark;
    /**
     * 天乙
     */
    private String tianYi;
    /**
     * 地乙
     */
    private String diYi;
    /**
     * 太乙
     */
    private String taiYi;
    /**
     * 伏吟
     */
    private List<String> fuYin;
    /**
     * 反吟
     */
    private List<String> fanYin;
    /**
     * 六仪击刑
     */
    private List<String> liuYiJiXing;
    /**
     * 奇仪入墓
     */
    private List<String> qiYiRuMu;

    /**
     * 值符旋转前宫位
     */
    private int oldZhiFuGong;
    /**
     * 值符旋转后宫位
     */
    private int newZhiFuGong;

    /**
     * 值使旋转前宫位
     */
    private int oldZhiShiGong;
    /**
     * 值使旋转后宫位
     */
    private int newZhiShiGong;

    /**
     * 地盘（1~9宫）
     */
    private List<String> diPan;
    /**
     * 天盘（1~9宫）
     */
    private List<String> tianPan;
    /**
     * 人盘（1~9宫）
     */
    private List<String> renPan;
    /**
     * 神盘（1~9宫）
     */
    private List<String> shenPan;

    /**
     * 地盘，附带六甲隐位（1~9宫）
     */
    private List<String> diPanPron;
    /**
     * 地盘中的三奇六仪（1~9宫）
     */
    private List<String> diSanQiLiuYi;
    /**
     * 地盘中的六甲隐位（1~9宫）
     */
    private List<String> diLiuJiaYinWei;
    /**
     * 天盘旋转后九星所携带的三奇六仪，只包含[天禽星]携带的三奇六仪（1~9宫）
     */
    private List<String> tianPanQiYiToTianQin;
    /**
     * 天盘旋转后九星所携带的三奇六仪，不包含[天禽星]携带的三奇六仪（1~9宫）
     */
    private List<String> tianPanQiYiExTianQin;

    /**
     * 十干克应（1~9宫）
     */
    private Map<Integer, List<String>> shiGanKeYing;
    /**
     * 八门克应（1~9宫）
     */
    private Map<Integer, List<String>> baMenKeYing;
    /**
     * 八门静应（1~9宫）
     */
    private List<String> baMenJingYing;
    /**
     * 八门动应（1~9宫）
     */
    private List<String> baMenDongYing;
    /**
     * 星门克应（1~9宫）
     */
    private Map<Integer, List<String>> xingMenKeYing;
    /**
     * 九星时应（1~9宫）
     */
    private Map<Integer, List<String>> jiuXingShiYing;

    /**
     * 九遁（1~9宫）
     */
    private Map<Integer, List<String>> jiuDun;

    /**
     * 月将（如：子）
     */
    private String yueJiang;
    /**
     * 月将神（如：登明）
     */
    private String yueJiangShen;

//************************************************************************************************************************************

    /**
     * 使用默认设置初始化（默认使用当前公历日期）
     */
    public ZhuanShiJiaQiMen() {
        ZhuanShiJiaQiMenSetting setting = new ZhuanShiJiaQiMenSetting();
        setData(setting); // 获取并设置数据
    }

    /**
     * 使用公历日期初始化
     *
     * @param date 公历日期
     */
    public ZhuanShiJiaQiMen(Date date) {
        ZhuanShiJiaQiMenSetting setting = new ZhuanShiJiaQiMenSetting(date);
        setData(setting); // 获取并设置数据
    }

    /**
     * 使用日期初始化
     *
     * @param date     公历日期
     * @param dateType 日期类型（0:公历。1:农历）
     */
    public ZhuanShiJiaQiMen(Date date, int dateType) {
        ZhuanShiJiaQiMenSetting setting = new ZhuanShiJiaQiMenSetting(date, dateType);
        setData(setting); // 获取并设置数据
    }

    /**
     * 使用公历年月日时初始化
     *
     * @param year  公历年（0~9999）
     * @param month 公历月（1~12）
     * @param day   公历日
     * @param hour  公历时（0~24）
     */
    public ZhuanShiJiaQiMen(int year, int month, int day, int hour) {
        ZhuanShiJiaQiMenSetting setting = new ZhuanShiJiaQiMenSetting(year, month, day, hour);
        setData(setting); // 获取并设置数据
    }

    /**
     * 使用年月日时初始化
     *
     * @param year     年（0~9999）
     * @param month    月（1~12）
     * @param day      日
     * @param hour     时（0~24）
     * @param dateType 日期类型（0:公历。1:农历）
     */
    public ZhuanShiJiaQiMen(int year, int month, int day, int hour, int dateType) {
        ZhuanShiJiaQiMenSetting setting = new ZhuanShiJiaQiMenSetting(year, month, day, hour, dateType);
        setData(setting); // 获取并设置数据
    }

    /**
     * 使用自定义设置初始化（若未设置日期则默认使用当前公历日期）
     *
     * @param setting 设置
     */
    public ZhuanShiJiaQiMen(ZhuanShiJiaQiMenSetting setting) {
        setData(setting); // 获取并设置数据
    }

//====================================================================================================================================

    /**
     * 获取并设置数据
     *
     * @param setting 设置
     */
    private void setData(ZhuanShiJiaQiMenSetting setting) {

        // 初始化自定义数据
        initialize(setting);

        // 计算数据
        baZiData(); // 计算八字、八字五行、八字纳音、八字旬空
        fuTouAndJieQi(setting); // 计算符头和节气
        sanYuan(); // 计算三元
        yinYangDun(); // 计算阴阳遁
        juShu(); // 计算局数
        diQiYiLiuJia(); // 计算地盘中的[三奇六仪]和[六甲隐位]
        xunShou(); // 计算旬首
        xunKong(); // 计算旬空
        fuShi(); // 计算值符和值使
        liuJiaXunKong(); // 计算六甲旬空、落宫、标识
        yiMa(); // 计算驿马、落宫、标识
        diPan(); // 计算地盘
        tianPan(); // 计算天盘
        renPan(); // 计算人盘
        shenPan(); // 计算神盘
        tianYiDiYiTaiYi(); // 计算天乙、地乙、太乙
        fuYin(); // 计算伏吟
        fanYin(); // 计算反吟
        liuYiJiXing(); // 计算六仪击刑
        qiYiRuMu(); // 计算奇仪入墓
        shiGanKeYing(); // 计算十干克应
        baMenKeYing(); // 计算八门克应
        baMenJingYing(); // 计算八门静应
        baMenDongYing(); // 计算八门动应
        xingMenKeYing(); // 计算星门克应
        jiuXingShiYing(); // 计算九星时应
        jiuDun(); // 计算九遁
        yueJiang(); // 计算月将、月将神

//        System.gc();

    }

    /**
     * 初始化自定义数据
     *
     * @param setting 设置
     */
    private void initialize(ZhuanShiJiaQiMenSetting setting) {

        // 1.1、☆判断日期类型并返回公历日期、农历日期
        Map<String, Object> DateTypeMap = ZhuanShiJiaQiMenUtil.isDateType(setting);
        // 1.2、设置日期
        this.solar = (Solar) DateTypeMap.get("solar"); // 设置公历日期
        this.lunar = (Lunar) DateTypeMap.get("lunar"); // 设置农历日期

        // 2、设置星期
        this.week = "周" + getLunar().getWeekInChinese();

        // 3.1、☆判断干支设置并返回干支
        Map<String, List<String>> ganZhiMap = ZhuanShiJiaQiMenUtil.isGanZhi(setting, getLunar());
        // 3.2、设置年干支
        List<String> yearGanZhi = ganZhiMap.get("yearGanZhi");
        this.yearGan = yearGanZhi.get(0); // 年干
        this.yearZhi = yearGanZhi.get(1); // 年支
        this.yearGanZhi = yearGanZhi.get(2); // 年干支
        // 3.3、设置月干支
        List<String> monthGanZhi = ganZhiMap.get("monthGanZhi");
        this.monthGan = monthGanZhi.get(0); // 月干
        this.monthZhi = monthGanZhi.get(1); // 月支
        this.monthGanZhi = monthGanZhi.get(2); // 月干支
        // 3.4、设置日干支
        List<String> dayGanZhi = ganZhiMap.get("dayGanZhi");
        this.dayGan = dayGanZhi.get(0); // 日干
        this.dayZhi = dayGanZhi.get(1); // 日支
        this.dayGanZhi = dayGanZhi.get(2); // 日干支
        // 3.5、设置时干支
        List<String> hourGanZhi = ganZhiMap.get("hourGanZhi");
        this.hourGan = hourGanZhi.get(0); // 时干
        this.hourZhi = hourGanZhi.get(1); // 时支
        this.hourGanZhi = hourGanZhi.get(2); // 时干支

    }

    /**
     * 获取八字、八字五行、八字纳音、八字旬空
     */
    private void baZiData() {

        EightChar ec = getLunar().getEightChar();

        // 1、设置八字
        this.baZi = Arrays.asList(getYearGanZhi(), getMonthGanZhi(), getDayGanZhi(), getHourGanZhi());

        // 2、设置八字五行
        this.baZiWuXing = Arrays.asList(ec.getYearWuXing(), ec.getMonthWuXing(), ec.getDayWuXing(), ec.getTimeWuXing());

        // 3、设置八字纳音
        this.baZiNaYin = Arrays.asList(ec.getYearNaYin(), ec.getMonthNaYin(), ec.getDayNaYin(), ec.getTimeNaYin());

        // 4、设置八字旬空
        this.baZiXunKong = Arrays.asList(ec.getYearXunKong(), ec.getMonthXunKong(), ec.getDayXunKong(), ec.getTimeXunKong());

    }

    /**
     * 计算符头和节气（TODO：待优化）
     */
    private void fuTouAndJieQi(ZhuanShiJiaQiMenSetting setting) {

        /*
            ★1、情况一：当天日干支是符头、当天是节气，则保存符头和节气

            ★2、情况二：当天日干支是符头、但当天不是节气，需保存符头并向前查找节气

            ★3、情况三：当天日干支不是符头、当天是节气，需保存节气并向前查找符头

            ★4、情况四：当天日干支不是符头、当天不是节气，需要按天向前查找符头和节气
                   1) 情况四之一：既碰到符头又碰到节气，则保存符头和节气
                   2) 情况四之二：若先碰到节气但未碰到符头，需保存节气并向前查找符头
                   3) 情况四之三：若先碰到符头但未碰到节气，需保存符头并向前查找节气
         */

        String dayGanZhi = getDayGanZhi(); // 日干支
        String[] sanYuanFuTou = ZhuanShiJiaQiMenMap.SAN_YUAN_FU_TOU; // 三元符头

        // ★1、情况一：当天日干支是符头、当天是节气，则保存符头和节气（▲例：农历二〇二二年八月廿八）
        for (String foTou : sanYuanFuTou) {
            if (dayGanZhi.equals(foTou) && !"".equals(getLunar().getJieQi())) {
                this.fuTou = dayGanZhi; // 保存符头
                this.jieQi = getLunar().getJieQi(); // 保存节气
                return;
            }
        }

        // ★2、情况二：当天日干支是符头、但当天不是节气，需保存符头并向前查找节气（▲例：农历二〇二二年八月十八）
        for (String foTou : sanYuanFuTou) {
            if (dayGanZhi.equals(foTou) && "".equals(getLunar().getJieQi())) {
                this.fuTou = dayGanZhi; // 保存符头
                this.jieQi = getLunar().getPrevJieQi(true).getName(); // 获取上一个节气（按天计算）
                return;
            }
        }

        // ★3、情况三：当天日干支不是符头、当天是节气，需保存节气并向前查找符头（▲例：农历二〇二二年八月十二）
        for (int i = 0; i < sanYuanFuTou.length; i++) {
            if (!dayGanZhi.equals(sanYuanFuTou[i]) && !"".equals(getLunar().getJieQi())) {
                String jieQi = getLunar().getJieQi(); // 当天节气
                // 3.1、获取向前第i天的日干支（晚子时日干支算明天）
                if (setting.getDayGanZhiSet() == ZhuanShiJiaQiMenEnum.DAY_GAN_ZHI_TOMORROW.getMark()) dayGanZhi = getLunar().next(-i).getDayInGanZhiExact();
                // 3.2、获取向前第i天的日干支（晚子时日柱算当天）
                if (setting.getDayGanZhiSet() == ZhuanShiJiaQiMenEnum.DAY_GAN_ZHI_TODAY.getMark()) dayGanZhi = getLunar().next(-i).getDayInGanZhiExact2();
                // 3.3、若向前第i天的日柱为符头则记录符头
                for (String foTou : sanYuanFuTou) {
                    if (dayGanZhi.equals(foTou)) {
                        this.fuTou = dayGanZhi; // 保存符头
                        this.jieQi = jieQi; // 保存节气
                        return;
                    }
                }
            }
        }

        // ★4、情况四：当天日干支不是符头、当天不是节气，需要按天向前查找符头和节气
        for (int i = 0; i < sanYuanFuTou.length; i++) {
            if (!dayGanZhi.equals(sanYuanFuTou[i]) && "".equals(getLunar().getJieQi())) {
                // 获取向前第i天的日干支（晚子时日干支算明天）
                if (setting.getDayGanZhiSet() == ZhuanShiJiaQiMenEnum.DAY_GAN_ZHI_TOMORROW.getMark()) dayGanZhi = getLunar().next(-i).getDayInGanZhiExact();
                // 获取向前第i天的日干支（晚子时日柱算当天）
                if (setting.getDayGanZhiSet() == ZhuanShiJiaQiMenEnum.DAY_GAN_ZHI_TODAY.getMark()) dayGanZhi = getLunar().next(-i).getDayInGanZhiExact2();
                String jieQi = getLunar().next(-i).getJieQi(); // 获取向前第i天的节气
                // 4.1、情况四之一：既碰到符头又碰到节气，则保存符头和节气（▲例：农历二〇二二年八月廿九）
                for (String foTou : sanYuanFuTou) {
                    if (dayGanZhi.equals(foTou) && !"".equals(jieQi)) {
                        this.fuTou = dayGanZhi; // 保存符头
                        this.jieQi = jieQi; // 保存节气
                        return;
                    }
                }
                // 4.2、情况四之二：若先碰到节气但未碰到符头，需保存节气并向前查找符头（▲例：农历二〇二〇年八月廿八）
                for (int j = 0; j < sanYuanFuTou.length; j++) {
                    if (!"".equals(jieQi) && !dayGanZhi.equals(sanYuanFuTou[i])) {
                        // 获取向前第i天的日干支（晚子时日干支算明天）
                        if (setting.getDayGanZhiSet() == ZhuanShiJiaQiMenEnum.DAY_GAN_ZHI_TOMORROW.getMark()) dayGanZhi = getLunar().next(-i).getDayInGanZhiExact();
                        // 获取向前第i天的日干支（晚子时日柱算当天）
                        if (setting.getDayGanZhiSet() == ZhuanShiJiaQiMenEnum.DAY_GAN_ZHI_TODAY.getMark()) dayGanZhi = getLunar().next(-i).getDayInGanZhiExact2();
                        // 若向前第i天的日柱为符头则记录符头
                        for (String foTou : sanYuanFuTou) {
                            if (dayGanZhi.equals(foTou)) {
                                this.fuTou = dayGanZhi; // 保存符头
                                this.jieQi = jieQi; // 保存节气
                                return;
                            }
                        }
                    }
                }
                // 4.3、情况四之三：若先碰到符头但未碰到节气，需保存符头并向前查找节气（▲例：农历二〇二二年八月十四）
                for (String foTou : sanYuanFuTou) {
                    if (dayGanZhi.equals(foTou) && "".equals(jieQi)) {
                        this.fuTou = dayGanZhi; // 保存符头
                        this.jieQi = getLunar().getPrevJieQi(true).getName(); // 保存节气
                        return;
                    }
                }
            }
        }

    }

    /**
     * 计算三元
     */
    private void sanYuan() {

        Map<Integer, List<String>> sanYuanRiZhu = ZhuanShiJiaQiMenMap.SAN_YUAN_RI_ZHU; // 三元日柱

        // 遍历三元日柱
        A:
        for (int i = 0; i < sanYuanRiZhu.size(); i++) {
            // 获取每一元中的干支
            List<String> yuanZhu = sanYuanRiZhu.get(i);
            // 判断日干支属于哪一元
            for (String value : yuanZhu) {
                if (getDayGanZhi().equals(value)) {
                    if (i == 0) {
                        this.sanYuan = ZhuanShiJiaQiMenConstant.SHANG_YUAN; // 上元
                    } else if (i == 1) {
                        this.sanYuan = ZhuanShiJiaQiMenConstant.ZHONG_YUAN; // 中元
                    } else if (i == 2) {
                        this.sanYuan = ZhuanShiJiaQiMenConstant.XIA_YUAN; // 下元
                    }
                    break A;
                }
            }
        }

    }

    /**
     * 计算阴阳遁
     */
    private void yinYangDun() {

        Map<Integer, List<String>> yinYangDun = ZhuanShiJiaQiMenMap.YIN_YANG_DUN; // 二十四节气对应阴阳遁

        // 遍历二十四节气对应阴阳遁
        A:
        for (int i = 0; i < yinYangDun.size(); i++) {
            // 获取阴阳遁的节气
            List<String> dun = yinYangDun.get(i);
            // 判断节气属于阴遁还是阳遁
            for (String value : dun) {
                if (getJieQi().equals(value)) {
                    if (i == 0) {
                        this.yinYangDun = ZhuanShiJiaQiMenConstant.YANG_DUN; // 阳遁
                    } else {
                        this.yinYangDun = ZhuanShiJiaQiMenConstant.YIN_DUN; // 阴遁
                    }
                    break A;
                }
            }
        }

    }

    /**
     * 计算旬空
     */
    private void xunKong() {

        // 1、设置旬空
        EightChar ec = getLunar().getEightChar();
        this.xunKong = Arrays.asList(ec.getYearXunKong(), ec.getMonthXunKong(), ec.getDayXunKong(), ec.getTimeXunKong());

    }

    /**
     * 计算局数
     */
    private void juShu() {

        Map<String, List<Integer>> juShu = ZhuanShiJiaQiMenMap.JU_SHU; // 二十四节气对应局数

        // 遍历二十四节气对应局数
        A:
        for (int i = 0; i < juShu.size(); i++) {
            // 获取节气对应的三元局数
            List<Integer> shu = juShu.get(getJieQi());
            for (int j = 0; j < shu.size(); j++) {
                // 根据三元判断所用局数
                switch (getSanYuan()) {
                    case ZhuanShiJiaQiMenConstant.SHANG_YUAN: // 上元
                        this.juShu = shu.get(0);
                        break A;
                    case ZhuanShiJiaQiMenConstant.ZHONG_YUAN: // 中元
                        this.juShu = shu.get(1);
                        break A;
                    case ZhuanShiJiaQiMenConstant.XIA_YUAN: // 下元
                        this.juShu = shu.get(2);
                        break A;
                }
            }
        }


    }

    /**
     * 计算地盘中的[三奇六仪]和[六甲隐位]
     */
    private void diQiYiLiuJia() {

        // 1.1、阳遁
        if (ZhuanShiJiaQiMenConstant.YANG_DUN.equals(getYinYangDun())) {
            this.diSanQiLiuYi = ZhuanShiJiaQiMenMap.DI_YANG_QI_YI.get(getJuShu()); // 保存三奇六仪
            this.diLiuJiaYinWei = ZhuanShiJiaQiMenMap.DI_YANG_LIU_JIA.get(getJuShu()); // 保存六甲隐位
        } else {
            // 1.2、阴遁
            this.diSanQiLiuYi = ZhuanShiJiaQiMenMap.DI_YIN_QI_YI.get(getJuShu()); // 保存三奇六仪
            this.diLiuJiaYinWei = ZhuanShiJiaQiMenMap.DI_YIN_LIU_JIA.get(getJuShu()); // 保存六甲隐位
        }

    }

    /**
     * 计算旬首
     */
    private void xunShou() {

        // 1、六十甲子对应的旬首
        Map<String, List<String>> sixJiaZiXunShou = ZhuanShiJiaQiMenMap.SIX_JIA_ZI_XUN_SHOU;

        // 2、根据时干支获取旬首
        String xunShou = sixJiaZiXunShou.get(getHourGanZhi()).get(0); // 旬首（如：甲子）
        String xunShouYiZhang = sixJiaZiXunShou.get(getHourGanZhi()).get(1); // 旬首仪仗（如：戊）

        // 3、设置旬首、旬首仪仗
        this.xunShou = xunShou; // 旬首
        this.xunShouYiZhang = xunShouYiZhang; // 旬首仪仗

    }

    /**
     * 计算值符和值使
     */
    private void fuShi() {

        // 1、根据旬首和六甲隐位获取旬首落宫
        for (int i = 0; i < getDiLiuJiaYinWei().size(); i++) {
            if (getXunShou().equals(getDiLiuJiaYinWei().get(i))) {
                this.xunShouGong = i + 1; // 旬首落宫（即：值符和值符落宫）
                this.oldZhiFuGong = i + 1; // 值符旋转前落宫
                this.oldZhiShiGong = i + 1; // 值使旋转前落宫
                break;
            }
        }

        // 2、根据旬首落宫获取[值符]和[值使]
        // 2.1、设置值符
        this.zhiFu = ZhuanShiJiaQiMenMap.JIU_XING_INITIAL[getXunShouGong() - 1];
        // 2.2、设置值使
        if (ZhuanShiJiaQiMenConstant.TIAN_QIN.equals(ZhuanShiJiaQiMenMap.JIU_XING_INITIAL[getXunShouGong() - 1]) || getXunShouGong() == 5) {
            String zhiShi = zhiShi(); // 计算并返回值使（天禽星为值符时：一律用[死门]为值使）
//            String zhiShi = zhiShi2(getYinYangDun()); // 计算并返回值使（天禽星为值符时：根据阴阳遁判断值使）
//            String zhiShi = zhiShi3(getJieQi()); // 计算并返回值使（天禽星为值符时：根据节气判断值使）
            this.zhiShi = zhiShi;
        } else {
            this.zhiShi = ZhuanShiJiaQiMenMap.BA_MEN_INITIAL[getXunShouGong() - 1];
        }

    }

    /**
     * 计算六甲旬空、落宫、标识
     */
    private void liuJiaXunKong() {

        // 1、设置六甲旬空
        this.liuJiaXunKong = ZhuanShiJiaQiMenMap.LIU_JIA_XUN_KONG.get(getXunShou());

        // 2、设置六甲旬空落宫
        this.liuJiaXunKongGong = ZhuanShiJiaQiMenMap.LIU_JIA_XUN_KONG_GONG.get(getLiuJiaXunKong());

        // 3、设置六甲旬空落宫标识
        List<String> list = CommonUtil.addListEmpty(9);
        for (int i = 0; i < getLiuJiaXunKongGong().size(); i++) {
            list.set(getLiuJiaXunKongGong().get(i) - 1, ZhuanShiJiaQiMenConstant.KONG); // ○
        }
        this.liuJiaXunKongGongMark = list;

    }

    /**
     * 计算驿马、落宫、标识
     */
    private void yiMa() {

        String hourZhi = getHourZhi(); // 时支

        // 1、设置驿马
        this.yiMa = ZhuanShiJiaQiMenMap.YI_MA.get(hourZhi);

        // 2、设置驿马落宫
        this.yiMaGong = ZhuanShiJiaQiMenMap.YI_MA_GONG.get(getYiMa());

        // 3、设置驿马落宫标识
        List<String> list = CommonUtil.addListEmpty(9);
        list.set(getYiMaGong() - 1, ZhuanShiJiaQiMenConstant.MA); // 马
        this.yiMaGongMark = list;

    }

    /**
     * 计算地盘
     */
    private void diPan() {

        List<String> qiYi = getDiSanQiLiuYi(); // 三奇六仪
        List<String> liuJia = getDiLiuJiaYinWei(); // 六甲隐位

        // 合并（三奇六仪+六甲隐位）
        List<String> diPanPron = new ArrayList<>();
        for (int i = 0; i < qiYi.size(); i++) {
            for (int j = 0; j < liuJia.size(); j++) {
                if ("".equals(liuJia.get(j))) {
                    diPanPron.add(j, qiYi.get(i));
                } else {
                    diPanPron.add(j, qiYi.get(i) + "(" + liuJia.get(j) + ")");
                }
                i++;
            }
        }

        this.diPan = getDiSanQiLiuYi(); // 不附带六甲隐位（即：三奇六仪）
        this.diPanPron = diPanPron; // 附带六甲隐位（即：三奇六仪+六甲隐位）

    }

    /**
     * 计算天盘
     */
    private void tianPan() {

        // 1、若时干为甲，则使用旬首仪仗进行判断
        String hourGan = getHourGan(); // 时干
        if (ZhuanShiJiaQiMenConstant.JIA_GAN.equals(hourGan)) {
            hourGan = getXunShouYiZhang();
        }

        // 2、计算时干落宫
        List<String> diSanQiLiuYi = getDiSanQiLiuYi(); // 地盘中的三奇六仪（1~9宫）
        for (int i = 0; i < diSanQiLiuYi.size(); i++) {
            if (hourGan.equals(diSanQiLiuYi.get(i))) {
                // 2.1、设置值符旋转后落入的宫位（转盘奇门中，若值符落五宫时，一般需要寄二宫）
                this.newZhiFuGong = i + 1;
                if (getNewZhiFuGong() == 5) {
                    this.newZhiFuGong = 2;
                }
                break;
            }
        }

        // 3、将九星依次加入宫位中
        Map<Integer, List<String>> jiuXingShun = ZhuanShiJiaQiMenMap.JIU_XING_SHUN; // 九星位置（顺转九宫）
        for (int i = 0; i < jiuXingShun.size(); i++) {
            List<String> jiuXing = jiuXingShun.get(i);
            // 3.1、若值符为'天禽'，则使用'天芮'进行判断
            String zhiFu = getZhiFu();
            if (zhiFu.equals(ZhuanShiJiaQiMenConstant.TIAN_QIN)) {
                zhiFu = ZhuanShiJiaQiMenConstant.TIAN_RUI;
            }
            // 3.2、将'天芮'更换为：芮禽
            if (zhiFu.equals(jiuXing.get(getNewZhiFuGong() - 1))) {
                List<String> tianPan = new ArrayList<>(jiuXing);
                for (int j = 0; j < jiuXing.size(); j++) {
                    if (ZhuanShiJiaQiMenConstant.TIAN_RUI.equals(jiuXing.get(j))) {
                        tianPan.set(j, ZhuanShiJiaQiMenConstant.RUI_QIN); // 芮禽
                        break;
                    }
                }
                this.tianPan = tianPan;
                break;
            }
        }

        // 4、计算原宫九星所携带的三奇六仪（只包含'天禽星'所携带的三奇六仪）
        List<String> tianPanQiYiToTianQin = CommonUtil.addListEmpty(9); // 存放原宫九星所携带的三奇六仪（只包含'天禽星'所携带的三奇六仪）
        for (int i = 0; i < getTianPan().size(); i++) {
            if (!"".equals(getTianPan().get(i))) {
                if (ZhuanShiJiaQiMenConstant.RUI_QIN.substring(1, 2).equals(getTianPan().get(i).substring(1, 2))) {
                    tianPanQiYiToTianQin.set(i, getDiSanQiLiuYi().get(4));
                }
            }
        }
        this.tianPanQiYiToTianQin = tianPanQiYiToTianQin;

        // 5、计算原宫九星所携带的三奇六仪（不包含'天禽星'所携带的三奇六仪）
        Map<String, Integer> jiuXingInitial = ZhuanShiJiaQiMenMap.JIU_XING_INITIAL2; // 九星原始宫位（1~9宫）
        List<String> tianPanQiYiExTianQin = new ArrayList<>(); // 存放原宫九星所携带的三奇六仪（不包含'天禽星'所携带的三奇六仪）
        int index;
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < getDiSanQiLiuYi().size(); j++) {
                if (i == 4) {
                    tianPanQiYiExTianQin.add(i, getDiSanQiLiuYi().get(i)); // 九星原始宫位所携带的三奇六仪
                } else {
                    if (ZhuanShiJiaQiMenConstant.RUI_QIN.substring(0, 1).equals(getTianPan().get(i).substring(0, 1))) {
                        index = jiuXingInitial.get(ZhuanShiJiaQiMenConstant.TIAN_RUI) - 1; // 九星原始宫位
                    } else if (ZhuanShiJiaQiMenConstant.RUI_QIN.substring(1, 2).equals(getTianPan().get(i).substring(1, 2))) {
                        index = jiuXingInitial.get(ZhuanShiJiaQiMenConstant.TIAN_QIN) - 1; // 九星原始宫位
                    } else {
                        index = jiuXingInitial.get(getTianPan().get(i)) - 1; // 九星原始宫位
                    }
                    tianPanQiYiExTianQin.add(i, getDiSanQiLiuYi().get(index)); // 九星原始宫位所携带的三奇六仪
                }
                i++;
            }
        }
        this.tianPanQiYiExTianQin = tianPanQiYiExTianQin;

    }

    /**
     * 计算人盘
     */
    private void renPan() {

        String hourZhi = getHourZhi(); // 时支
        String[] zhi = ZhuanShiJiaQiMenMap.DI_ZHI; // 地支
        String xunShouZhi = getXunShou().substring(1, 2); // 旬首中的地支

        // 1、获取旬首中的地支在第几号索引
        int xunShouZhiIndex = 0; // 记录旬首中的地支索引
        for (int i = 0; i < zhi.length; i++) {
            if (xunShouZhi.equals(zhi[i])) {
                xunShouZhiIndex = i;
                break;
            }
        }

        // 2、接着旬首中的地支索引值向后查找时支所在位置
        int hourZhiCount = 0; // 记录找到时支时所需要查找的次数
        for (int i = 0; i < zhi.length; i++) {
            if (xunShouZhiIndex == zhi.length) {
                // 2.1、若查找至最后一个元素时仍未找到地支，则重置旬首中的地支索引值
                xunShouZhiIndex = 0;
            } else if (!hourZhi.equals(zhi[xunShouZhiIndex])) {
                // 2.2、未找到元素，继续查找
                hourZhiCount++; // 查找次数+1
                xunShouZhiIndex++; // 旬首中的地支索引+1
            } else {
                // 2.3、已找到元素，停止查找
                break;
            }
        }

        // 3、若[旬首中的地支]和[时支]不相同，说明值使落宫已改变
        int xunShouGong = getXunShouGong(); // 旬首落宫（即：值符和值符落宫）
        if (!xunShouZhi.equals(hourZhi)) {
            // 3.1、计算值使旋转后的宫位
            if (ZhuanShiJiaQiMenConstant.YANG_DUN.equals(getYinYangDun())) {
                // 3.2、阳遁用[值使旋转前宫位+一共查找的次数]获取旋转后值使所落宫位，顺排九宫
                for (int i = 0; i < hourZhiCount; i++) {
                    // 3.3、若值使旋转后的宫位大于等于9，则重新从第一宫开始判断
                    if (xunShouGong >= 9) {
                        xunShouGong = 1;
                    } else {
                        xunShouGong++;
                    }
                }
            } else {
                // 3.4、阴遁用[值使旋转前宫位+一共查找的次数]获取旋转后值使所落宫位，逆排九宫
                for (int i = 0; i < hourZhiCount; i++) {
                    // 3.5、若值使旋转后的宫位小于等于0，则重新从第九宫开始判断
                    if (xunShouGong <= 1) {
                        xunShouGong = 9;
                    } else {
                        xunShouGong--;
                    }
                }
            }
        }

        // 4、若值使旋转后落中五宫则寄二宫
        if (xunShouGong == 5) {
            this.newZhiShiGong = 2;
        } else {
            this.newZhiShiGong = xunShouGong;
        }

        // 5、计算人盘
        List<String> list = new ArrayList<>();
        Map<Integer, List<String>> baMenShun = ZhuanShiJiaQiMenMap.BA_MEN_SHUN_ZHUAN; // 八门位置（顺转九宫）
        for (int i = 0; i < baMenShun.size(); i++) {
            List<String> baMen = baMenShun.get(i);
            for (int j = 0; j < baMen.size(); j++) {
                if (baMen.get(getNewZhiShiGong() - 1).equals(getZhiShi())) {
                    list = baMen;
                    break;
                }
            }
        }

        // 6、设置人盘
        this.renPan = list;

    }

    /**
     * 计算神盘
     */
    private void shenPan() {

        /*
            根据小值符随大值符的原则，即：将小值符加在天盘大值符宫位上即可。
         */

        // 1、若值符落中五宫则寄二宫
        int newZhiFuGong = getNewZhiFuGong(); // [值符]旋转后宫位
        if (newZhiFuGong == 5) {
            newZhiFuGong = 2;
        }

        // 2、判断阴阳遁
        if (ZhuanShiJiaQiMenConstant.YANG_DUN.equals(getYinYangDun())) {
            // 2.1、阳遁顺转九宫【此处按小值符追随天盘大值符计算。当然还有另外一种方式：小值符追随地盘值符】
            this.shenPan = ZhuanShiJiaQiMenMap.BA_SHEN_SHUN_ZHUAN.get(newZhiFuGong);
        } else {
            // 2.2、阴遁逆转九宫【此处按小值符追随天盘大值符计算。当然还有另外一种方式：小值符追随地盘值符、
            this.shenPan = ZhuanShiJiaQiMenMap.BA_SHEN_NI_ZHUAN.get(newZhiFuGong);
        }

    }

    /**
     * 计算天乙、地乙、太乙
     */
    private void tianYiDiYiTaiYi() {

        /*
               天乙：值符飞落宫位的原宫星
               地乙：值使飞落宫位的原宫门
               太乙/元一：值使门
         */

        this.tianYi = ZhuanShiJiaQiMenMap.JIU_XING_INITIAL[getNewZhiFuGong() - 1]; // 天乙
        this.diYi = ZhuanShiJiaQiMenMap.BA_MEN_INITIAL[getNewZhiShiGong() - 1]; // 地乙
        this.taiYi = getZhiShi(); // 太乙

    }

    /**
     * 计算伏吟（TODO：待完善）
     */
    private void fuYin() {

        int isFuYin = 0; // 用于判断是否全局伏吟
        List<String> list = new ArrayList<>(); // 保存伏吟数据

        // 1、星伏吟（判断宫位数据是否符合：坎一宫有天蓬星，离九宫有天英星）
        if (ZhuanShiJiaQiMenConstant.TIAN_PENG.equals(getTianPan().get(0)) && ZhuanShiJiaQiMenConstant.TIAN_YING.equals(getTianPan().get(8))) {
            list.add(ZhuanShiJiaQiMenConstant.JIU_XING_FU_YIN); // 九星伏吟
            isFuYin++;
        }

        // 2、门伏吟（判断宫位数据是否符合：坎一宫有休门，离九宫有景门）
        if (ZhuanShiJiaQiMenConstant.XIU_MEN.equals(getTianPan().get(0)) && ZhuanShiJiaQiMenConstant.JING_MEN_1.equals(getTianPan().get(8))) {
            list.add(ZhuanShiJiaQiMenConstant.BA_MEN_FU_YIN); // 八门伏吟
            isFuYin++;
        }

        // 3、神伏吟（判断宫位数据是否符合：坎一宫有值符，离九宫有白虎）
        if (ZhuanShiJiaQiMenConstant.ZHI_FU.equals(getShenPan().get(0)) && ZhuanShiJiaQiMenConstant.BAI_HU.equals(getShenPan().get(8))) {
            list.add(ZhuanShiJiaQiMenConstant.BA_SHEN_FU_YIN); // 八神伏吟
            isFuYin++;
        }

        // 4、奇仪伏吟（判断宫位数据是否符合：坎一宫中的地盘三奇六仪和天盘三奇六仪是否相同）
        if (getDiSanQiLiuYi().get(0).equals(getTianPanQiYiExTianQin().get(0))) {
            list.add(ZhuanShiJiaQiMenConstant.QI_YI_FU_YIN); // 奇仪伏吟
            isFuYin++;
        }

        // 5、判断是否为全局伏吟
//        if (isFuYin == 4) {
//            list = new ArrayList<>();
//            list.add(ZhuanShiJiaQiMenConstant.ALL_FU_YIN); // 全局伏吟
//        }

        this.fuYin = list;

    }

    /**
     * 计算反吟（TODO：待完善）
     */
    private void fanYin() {

        int isFanYin = 0; // 用于判断是否全局反吟
        List<String> list = new ArrayList<>(); // 保存反吟数据

        // 1、六仪反吟
        /*
            天盘甲子戊+地盘甲午辛
            天盘甲戌己+地盘甲辰壬
            天盘甲申庚+地盘甲寅癸
            天盘甲午辛+地盘甲子戊
            天盘甲辰壬+地盘甲戌己
            天盘甲寅癸+地盘甲申庚
         */
        List<String> diSanQiLiuYi = getDiSanQiLiuYi(); // 地盘三奇六仪
        List<String> ex = getTianPanQiYiExTianQin(); // 天盘旋转后九星所携带的三奇六仪，不包含[天禽星]携带的三奇六仪（1~9宫）
        List<String> to = getTianPanQiYiToTianQin(); // 天盘旋转后九星所携带的三奇六仪，只包含[天禽星]携带的三奇六仪（1~9宫）
        for (int i = 0; i < 9; i++) {
            // 天盘甲子戊+地盘甲午辛
            if ((ZhuanShiJiaQiMenConstant.WU_GAN.equals(ex.get(i)) || ZhuanShiJiaQiMenConstant.WU_GAN.equals(to.get(i))) && ZhuanShiJiaQiMenConstant.XIN_GAN.equals(diSanQiLiuYi.get(i))) {
                list.add(ZhuanShiJiaQiMenConstant.LIU_YI_FAN_YIN); // 六仪反吟
                isFanYin++;
                break;
            }
            // 天盘甲戌己+地盘甲辰壬
            if ((ZhuanShiJiaQiMenConstant.JI_GAN.equals(ex.get(i)) || ZhuanShiJiaQiMenConstant.WU_GAN.equals(to.get(i))) && ZhuanShiJiaQiMenConstant.REN_GAN.equals(diSanQiLiuYi.get(i))) {
                list.add(ZhuanShiJiaQiMenConstant.LIU_YI_FAN_YIN); // 六仪反吟
                isFanYin++;
                break;
            }
            // 天盘甲申庚+地盘甲寅癸
            if ((ZhuanShiJiaQiMenConstant.GENG_GAN.equals(ex.get(i)) || ZhuanShiJiaQiMenConstant.WU_GAN.equals(to.get(i))) && ZhuanShiJiaQiMenConstant.GUI_GAN.equals(diSanQiLiuYi.get(i))) {
                list.add(ZhuanShiJiaQiMenConstant.LIU_YI_FAN_YIN); // 六仪反吟
                isFanYin++;
                break;
            }
            // 天盘甲午辛+地盘甲子戊
            if ((ZhuanShiJiaQiMenConstant.XIN_GAN.equals(ex.get(i)) || ZhuanShiJiaQiMenConstant.WU_GAN.equals(to.get(i))) && ZhuanShiJiaQiMenConstant.WU_GAN.equals(diSanQiLiuYi.get(i))) {
                list.add(ZhuanShiJiaQiMenConstant.LIU_YI_FAN_YIN); // 六仪反吟
                isFanYin++;
                break;
            }
            // 天盘甲辰壬+地盘甲戌己
            if ((ZhuanShiJiaQiMenConstant.REN_GAN.equals(ex.get(i)) || ZhuanShiJiaQiMenConstant.WU_GAN.equals(to.get(i))) && ZhuanShiJiaQiMenConstant.JI_GAN.equals(diSanQiLiuYi.get(i))) {
                list.add(ZhuanShiJiaQiMenConstant.LIU_YI_FAN_YIN); // 六仪反吟
                isFanYin++;
                break;
            }
            // 天盘甲寅癸+地盘甲申庚
            if ((ZhuanShiJiaQiMenConstant.GUI_GAN.equals(ex.get(i)) || ZhuanShiJiaQiMenConstant.WU_GAN.equals(to.get(i))) && ZhuanShiJiaQiMenConstant.GENG_GAN.equals(diSanQiLiuYi.get(i))) {
                list.add(ZhuanShiJiaQiMenConstant.LIU_YI_FAN_YIN); // 六仪反吟
                isFanYin++;
                break;
            }
        }

        // 2、星伏吟（判断宫位数据是否符合：坎一宫有天英星，离九宫有天蓬星）
        if (ZhuanShiJiaQiMenConstant.TIAN_YING.equals(getTianPan().get(0)) && ZhuanShiJiaQiMenConstant.TIAN_PENG.equals(getTianPan().get(8))) {
            list.add(ZhuanShiJiaQiMenConstant.JIU_XING_FAN_YIN); // 九星伏吟
            isFanYin++;
        }

        // 3、门伏吟（判断宫位数据是否符合：坎一宫有景门，离九宫有休门）
        if (ZhuanShiJiaQiMenConstant.JING_MEN_1.equals(getTianPan().get(0)) && ZhuanShiJiaQiMenConstant.XIU_MEN.equals(getTianPan().get(8))) {
            list.add(ZhuanShiJiaQiMenConstant.BA_MEN_FAN_YIN); // 八门伏吟
            isFanYin++;
        }

        // 4、神伏吟（判断宫位数据是否符合：坎一宫有白虎，离九宫有值符）
        if (ZhuanShiJiaQiMenConstant.BAI_HU.equals(getShenPan().get(0)) && ZhuanShiJiaQiMenConstant.ZHI_FU.equals(getShenPan().get(8))) {
            list.add(ZhuanShiJiaQiMenConstant.BA_SHEN_FAN_YIN); // 八神伏吟
            isFanYin++;
        }

        // 5、判断是否为全局反吟
//        if (isFanYin == 4) {
//            list = new ArrayList<>();
//            list.add(ZhuanShiJiaQiMenConstant.ALL_FAN_YIN); // 全局反吟
//        }

        this.fanYin = list;

    }

    /**
     * 计算六仪击刑
     */
    private void liuYiJiXing() {

        /*
            1、甲子戊：'戊'落震三宫，子卯相刑。
            2、甲戌己：'己'落坤二宫，戌未相刑。
            3、甲申庚：'庚'落艮八宫，申寅相刑。
            4、甲午辛：'辛'落离九宫，午午自刑。
            5、甲辰壬：'壬'落巽四宫，辰辰自刑。
            6、甲寅癸：'癸'落巽四宫，寅巳相刑。
        */

        List<String> list = new ArrayList<>(); // 保存六仪击刑
        List<String> ex = getTianPanQiYiExTianQin(); // 天盘旋转后九星所携带的三奇六仪，不包含[天禽星]携带的三奇六仪（1~9宫）
        List<String> to = getTianPanQiYiToTianQin(); // 天盘旋转后九星所携带的三奇六仪，只包含[天禽星]携带的三奇六仪（1~9宫）

        // 1.1、判断震三宫的天盘天干是否为'戊'
        if (ZhuanShiJiaQiMenConstant.WU_GAN.equals(to.get(2)) || ZhuanShiJiaQiMenConstant.WU_GAN.equals(ex.get(2))) {
            list.add(ZhuanShiJiaQiMenConstant.ZI_MAO_XING); // 子卯相刑(戊落震三宫)
        }
        // 1.2、判断坤二宫的天盘天干是否为'己'
        if (ZhuanShiJiaQiMenConstant.JI_GAN.equals(to.get(1)) || ZhuanShiJiaQiMenConstant.JI_GAN.equals(ex.get(1))) {
            list.add(ZhuanShiJiaQiMenConstant.XU_WEI_XING); // 戌未相刑(己落坤二宫)
        }
        // 1.3、判断艮八宫的天盘天干是否为'庚'
        if (ZhuanShiJiaQiMenConstant.GENG_GAN.equals(to.get(7)) || ZhuanShiJiaQiMenConstant.GENG_GAN.equals(ex.get(7))) {
            list.add(ZhuanShiJiaQiMenConstant.SHEN_YIN_XING); // 申寅相刑(庚落艮八宫)
        }
        // 1.4、判断离九宫的天盘天干是否为'辛'
        if (ZhuanShiJiaQiMenConstant.XIN_GAN.equals(to.get(8)) || ZhuanShiJiaQiMenConstant.XIN_GAN.equals(ex.get(8))) {
            list.add(ZhuanShiJiaQiMenConstant.WU_WU_XING); // 午午自刑(辛落离九宫)
        }
        // 1.5、判断巽四宫的天盘天干是否为'壬'
        if (ZhuanShiJiaQiMenConstant.REN_GAN.equals(to.get(3)) || ZhuanShiJiaQiMenConstant.REN_GAN.equals(ex.get(3))) {
            list.add(ZhuanShiJiaQiMenConstant.CHEN_CHEN_XING); // 辰辰自刑(壬落巽四宫)
        }
        // 1.6、判断巽四宫的天盘天干是否为'癸'
        if (ZhuanShiJiaQiMenConstant.GUI_GAN.equals(to.get(3)) || ZhuanShiJiaQiMenConstant.GUI_GAN.equals(ex.get(3))) {
            list.add(ZhuanShiJiaQiMenConstant.YIN_SI_XING); // 寅巳相刑(癸落巽四宫)
        }

        this.liuYiJiXing = list;

    }

    /**
     * 计算奇仪入墓
     */
    private void qiYiRuMu() {

        /*
            1、'乙'落坤二宫、乾六宫。
            2、'丙'落乾六宫。
            3、'丁'落艮八宫。
            4、'戊'落乾六宫。
            5、'己'落艮八宫。
            6、'庚'落艮八宫。
            7、'辛'落巽四宫。
            8、'壬'落巽四宫。
            9、'癸'落坤二宫。
        */

        List<String> list = new ArrayList<>(); // 保存三奇六仪入墓
        List<String> ex = getTianPanQiYiExTianQin(); // 天盘旋转后九星所携带的三奇六仪，不包含[天禽星]携带的三奇六仪（1~9宫）
        List<String> to = getTianPanQiYiToTianQin(); // 天盘旋转后九星所携带的三奇六仪，只包含[天禽星]携带的三奇六仪（1~9宫）

        // 2.1、判断坤二宫的天盘天干是否为'乙'
        if (ZhuanShiJiaQiMenConstant.YI_GAN.equals(to.get(1)) || ZhuanShiJiaQiMenConstant.YI_GAN.equals(ex.get(1))) {
            list.add(ZhuanShiJiaQiMenConstant.YI_ER_MU); // 乙入墓(坤二宫)
        }
        // 2.2、判断坤二宫的天盘天干是否为'癸'
        if (ZhuanShiJiaQiMenConstant.GUI_GAN.equals(to.get(1)) || ZhuanShiJiaQiMenConstant.GUI_GAN.equals(ex.get(1))) {
            list.add(ZhuanShiJiaQiMenConstant.GUI_ER_MU); // 癸入墓(坤二宫)
        }
        // 2.3、判断乾六宫的天盘天干是否为'乙'
        if (ZhuanShiJiaQiMenConstant.YI_GAN.equals(to.get(5)) || ZhuanShiJiaQiMenConstant.YI_GAN.equals(ex.get(5))) {
            list.add(ZhuanShiJiaQiMenConstant.YI_LIU_MU); // 乙入墓(乾六宫)
        }
        // 2.4、判断乾六宫的天盘天干是否为'丙'
        if (ZhuanShiJiaQiMenConstant.BING_GAN.equals(to.get(5)) || ZhuanShiJiaQiMenConstant.BING_GAN.equals(ex.get(5))) {
            list.add(ZhuanShiJiaQiMenConstant.BING_LIU_MU); // 丙入墓(乾六宫)
        }
        // 2.5、判断乾六宫的天盘天干是否为'戊'
        if (ZhuanShiJiaQiMenConstant.WU_GAN.equals(to.get(5)) || ZhuanShiJiaQiMenConstant.WU_GAN.equals(ex.get(5))) {
            list.add(ZhuanShiJiaQiMenConstant.WU_LIU_MU); // 戊入墓(乾六宫)
        }
        // 2.6、判断艮八宫的天盘天干是否为'丁'
        if (ZhuanShiJiaQiMenConstant.DING_GAN.equals(to.get(7)) || ZhuanShiJiaQiMenConstant.DING_GAN.equals(ex.get(7))) {
            list.add(ZhuanShiJiaQiMenConstant.DING_BA_MU); // 丁入墓(艮八宫)
        }
        // 2.7、判断艮八宫的天盘天干是否为'庚'
        if (ZhuanShiJiaQiMenConstant.GENG_GAN.equals(to.get(7)) || ZhuanShiJiaQiMenConstant.GENG_GAN.equals(ex.get(7))) {
            list.add(ZhuanShiJiaQiMenConstant.GENG_BA_MU); // 庚入墓(艮八宫)
        }
        // 2.8、判断艮八宫的天盘天干是否为'己'
        if (ZhuanShiJiaQiMenConstant.JI_GAN.equals(to.get(7)) || ZhuanShiJiaQiMenConstant.JI_GAN.equals(ex.get(7))) {
            list.add(ZhuanShiJiaQiMenConstant.JI_BA_MU); // 己入墓(艮八宫)
        }
        // 2.9、判断巽四宫的天盘天干是否为'辛'
        if (ZhuanShiJiaQiMenConstant.XIN_GAN.equals(to.get(3)) || ZhuanShiJiaQiMenConstant.XIN_GAN.equals(ex.get(3))) {
            list.add(ZhuanShiJiaQiMenConstant.XIN_SI_MU); // 辛入墓(巽四宫)
        }
        // 2.10、判断巽四宫的天盘天干是否为'壬'
        if (ZhuanShiJiaQiMenConstant.REN_GAN.equals(to.get(3)) || ZhuanShiJiaQiMenConstant.REN_GAN.equals(ex.get(3))) {
            list.add(ZhuanShiJiaQiMenConstant.REN_SI_MU); // 壬入墓(巽四宫)
        }

        this.qiYiRuMu = list;

    }

    /**
     * 计算十干克应
     */
    private void shiGanKeYing() {

        List<String> diPan = getDiPan(); // 地盘（1~9宫）
        Map<List<String>, List<String>> shiGanKeYing = ZhuanShiJiaQiMenMap.SHI_GAN_KE_YING; // 十干克应
        Map<Integer, List<String>> map = new HashMap<>(); // 保存十干克应关系

        // 1、计算九宫中的[天盘天干+地盘天干]对应的十干克应关系
        for (int i = 0; i < 9; i++) {
            List<String> to = CommonUtil.addList(getTianPanQiYiToTianQin().get(i), diPan.get(i)); // 地盘天干+只包含'天禽星'携带的天干
            List<String> ex = CommonUtil.addList(getTianPanQiYiExTianQin().get(i), diPan.get(i)); // 地盘天干+不包含'天禽星'携带的天干
            // 1.1、置空中五宫
            if (i == 4) {
                map.put(i, Collections.singletonList(""));
            } else {
                List<String> keYingListTo = shiGanKeYing.get(ex); // 地盘天干+不包含'天禽星'携带的天干的十干克应关系
                String keYingTo = ex.get(0) + "+" + ex.get(1) + "(" + keYingListTo.get(0) + ")：" + keYingListTo.get(1);
                // 1.2、该宫位中存在两个天盘天干，追加十干克应数据
                if (to.size() > 1) {
                    List<String> keYingListEx = shiGanKeYing.get(to); // 地盘天干+只包含'天禽星'携带的天干的十干克应关系
                    String keYingEx = to.get(0) + "+" + to.get(1) + "(" + keYingListEx.get(0) + ")：" + keYingListEx.get(1);
                    map.put(i, Arrays.asList(keYingEx, keYingTo));
                } else {
                    map.put(i, Collections.singletonList(keYingTo));
                }
            }
        }
        this.shiGanKeYing = map;

    }

    /**
     * 计算八门克应
     */
    private void baMenKeYing() {

        List<String> renPan = getRenPan(); // 人盘（1~9宫）
        List<String> diPan = getDiPan(); // 地盘（1~9宫）
        String[] baMenInitial = ZhuanShiJiaQiMenMap.BA_MEN_INITIAL;// 八门原始宫位（1~9宫）
        Map<List<String>, String> baMenKeYing = ZhuanShiJiaQiMenMap.BA_MEN_KE_YING; // 八门克应

        // 1、计算[人盘八门+地盘八门]的生克制化关系
        List<String> menMenData = new ArrayList<>(); // 保存九宫的[人盘八门+地盘八门]的生克制化关系
        for (int i = 0; i < 9; i++) {
            if (!"".equals(renPan.get(i))) {
                String newMen = renPan.get(i); // 人盘八门
                String oldMen = baMenInitial[i]; // 宫位中的原始八门
                List<String> menAndMen = Arrays.asList(newMen, oldMen); // 每一宫位中的[门+门]（例如：开+休）
                menMenData.add(newMen + "+" + oldMen + "：" + baMenKeYing.get(menAndMen)); // 例如→ 开门+休门：主见贵人财喜及开张铺店，贸易大吉。
            } else {
                menMenData.add(""); // 置空中五宫数据
            }
        }

        // 2、计算[人盘八门+地盘天干]的生克制化关系
        List<String> menDiGanData = new ArrayList<>(); // 保存九宫的[人盘八门+地盘天干]的生克制化关系
        for (int i = 0; i < 9; i++) {
            if (!"".equals(renPan.get(i))) {
                String newMen = renPan.get(i); // 人盘八门
                String diPanGan = diPan.get(i); // 地盘天干
                List<String> menAndDiGan = Arrays.asList(newMen, diPanGan); // 例如：开门+乙
                menDiGanData.add(newMen + "+" + diPanGan + "：" + baMenKeYing.get(menAndDiGan)); // 例如→ 开门+乙:小财可求。
            } else {
                menDiGanData.add(""); // 置空中五宫数据
            }
        }

        // 3、计算[人盘八门+天盘天干]的生克制化关系
        Map<Integer, List<String>> menTianGanData = new HashMap<>(); // 保存九宫的[门+天盘天干]对应信息
        for (int i = 0; i < 9; i++) {
            if (!"".equals(renPan.get(i))) {
                String baMen = renPan.get(i); // 人盘八门
                List<String> to = CommonUtil.addList(baMen, getTianPanQiYiToTianQin().get(i)); // 地盘天干+只包含'天禽星'携带的天干
                List<String> ex = CommonUtil.addList(baMen, getTianPanQiYiExTianQin().get(i)); // 地盘天干+不包含'天禽星'携带的天干
                // 3.1、置空中五宫
                if (i == 4) {
                    menTianGanData.put(i, Collections.singletonList(""));
                } else {
                    String baMenKeYingTo = baMenKeYing.get(ex); // 地盘天干+不包含'天禽星'携带的天干的八门克应数据
                    String keYingTo = ex.get(0) + "+" + ex.get(1) + "：" + baMenKeYingTo;
                    // 3.2、该宫位中存在两个天盘天干，追加八门克应数据
                    if (to.size() > 1) {
                        String baMenKeYingEx = baMenKeYing.get(to); // 地盘天干+只包含'天禽星'携带的天干的八门克应数据
                        String keYingEx = to.get(0) + "+" + to.get(1) + "：" + baMenKeYingEx;
                        menTianGanData.put(i, Arrays.asList(keYingEx, keYingTo));
                    } else {
                        menTianGanData.put(i, Collections.singletonList(keYingTo));
                    }
                }
            } else {
                menTianGanData.put(i, Collections.singletonList("")); // 置空中五宫数据
            }
        }

        // 4、整合[人盘八门+地盘八门]、[人盘八门+地盘天干]、[人盘八门+天盘天干]的生克制化关系
        List<String> list; // 保存单宫[人盘八门+地盘八门]、[人盘八门+地盘天干]、[人盘八门+天盘天干]的生克制化关系
        Map<Integer, List<String>> map = new HashMap<>(); // 保存九宫[人盘八门+地盘八门]、[人盘八门+地盘天干]、[人盘八门+天盘天干]的生克制化关系
        for (int i = 0; i < 9; i++) {
            // 4.1、置空中五宫
            if (i == 4) {
                map.put(i, Collections.singletonList(""));
            } else {
                list = new ArrayList<>();
                list.add(menMenData.get(i)); // [人盘八门+地盘八门]
                list.add(menDiGanData.get(i)); // [人盘八门+地盘天干]
                list.add(menTianGanData.get(i).get(0)); // [人盘八门+天盘天干]
                // 4.2、若某一宫位中的[门+天盘天干]信息个数大于1，则说明该宫位中存在两个天盘天干
                if (menTianGanData.get(i).size() > 1) {
                    list.add(menTianGanData.get(i).get(1)); // [人盘八门+天盘天干]
                }
                map.put(i, list);
            }
        }
        this.baMenKeYing = map;

    }

    /**
     * 计算八门静应
     */
    private void baMenJingYing() {

        this.baMenJingYing = men(ZhuanShiJiaQiMenMap.BA_MEN_KE_YING);

    }

    /**
     * 计算八门动应
     */
    private void baMenDongYing() {

        this.baMenDongYing = men(ZhuanShiJiaQiMenMap.BA_MEN_DONG_YING);

    }

    /**
     * 计算星门克应
     */
    private void xingMenKeYing() {

        List<String> tianPan = getTianPan(); // 天盘（1~9宫）
        List<String> renPan = getRenPan(); // 人盘（1~9宫）
        Map<List<String>, String> xingMenKeYing = ZhuanShiJiaQiMenMap.XING_MEN_KE_YING; // 星门克应

        // 1、计算九宫中的[九星+八门]的克应关系
        List<String> list = new ArrayList<>(); // 存放单宫的[九星+八门]对应信息
        Map<Integer, List<String>> map = new HashMap<>(); // 存放九宫的[九星+八门]对应信息
        for (int i = 0; i < 9; i++) {
            if (i != 4) {
                String xing = tianPan.get(i).substring(0, 1); // 天 或 芮
                if (ZhuanShiJiaQiMenConstant.TIAN.equals(xing)) {
                    // 1.1、宫位中不包含'天禽星'
                    List<String> xingMen = Arrays.asList(tianPan.get(i), renPan.get(i));
                    map.put(i, Collections.singletonList(tianPan.get(i) + ZhuanShiJiaQiMenConstant.XING + "+" + renPan.get(i) + "：" + xingMenKeYing.get(xingMen)));
                } else {
                    // 1.2、宫位中包含'天芮星'和'天禽星'
                    List<String> xingMen = Arrays.asList(ZhuanShiJiaQiMenConstant.TIAN_RUI, renPan.get(i));
                    list.add(ZhuanShiJiaQiMenConstant.TIAN_RUI + ZhuanShiJiaQiMenConstant.XING + "+" + renPan.get(i) + "：" + xingMenKeYing.get(xingMen));
                    list.add(ZhuanShiJiaQiMenConstant.TIAN_QIN + ZhuanShiJiaQiMenConstant.XING + "+" + renPan.get(i) + "：" + xingMenKeYing.get(xingMen));
                    map.put(i, list);
                }
            } else {
                map.put(i, Collections.singletonList("")); // 置空中五宫数据
            }
        }
        this.xingMenKeYing = map;

    }

    /**
     * 计算九星时应
     */
    private void jiuXingShiYing() {

        String hourZhi = getHourZhi(); // 时支
        List<String> tianPan = getTianPan(); // 天盘（1~9宫）
        Map<List<String>, String> jiuXingShiYing = ZhuanShiJiaQiMenMap.JIU_XING_SHI_YING; // 九星时应

        // 1、计算九宫中的[九星+时辰]的克应关系
        List<String> list = new ArrayList<>(); // 存放单宫的[九星+时辰]对应信息
        Map<Integer, List<String>> map = new HashMap<>(); // 存放九宫的[九星+时辰]对应信息
        for (int i = 0; i < 9; i++) {
            if (i != 4) {
                String xing = tianPan.get(i).substring(0, 1); // 天 或 芮
                if (ZhuanShiJiaQiMenConstant.TIAN.equals(xing)) { // 天
                    // 1.1、宫位中不包含'天禽星'
                    List<String> xingMen = Arrays.asList(tianPan.get(i), hourZhi);
                    map.put(i, Collections.singletonList(tianPan.get(i) + ZhuanShiJiaQiMenConstant.XING + "值" + hourZhi + "时：" + jiuXingShiYing.get(xingMen)));
                } else { // 芮
                    // 1.2、宫位中包含'天芮星'和'天禽星'
                    List<String> tianRui = Arrays.asList(ZhuanShiJiaQiMenConstant.TIAN_RUI, hourZhi);
                    List<String> tianQin = Arrays.asList(ZhuanShiJiaQiMenConstant.TIAN_QIN, hourZhi);
                    list.add(ZhuanShiJiaQiMenConstant.TIAN_RUI + ZhuanShiJiaQiMenConstant.XING + "值" + hourZhi + "时：" + jiuXingShiYing.get(tianRui));
                    list.add(ZhuanShiJiaQiMenConstant.TIAN_QIN + ZhuanShiJiaQiMenConstant.XING + "值" + hourZhi + "时：" + jiuXingShiYing.get(tianQin));
                    map.put(i, list);
                }
            } else {
                map.put(i, Collections.singletonList("")); // 置空中五宫数据
            }
        }
        this.jiuXingShiYing = map;

    }

    /**
     * 计算九遁
     */
    private void jiuDun() {

        List<String> list = new ArrayList<>(); //  保存单宫九遁
        Map<Integer, List<String>> map = new HashMap<>(); // 保存九宫九遁

        // 1、计算九遁
        List<String> tianDun = tianDun(); // 天遁
        List<String> diDun = diDun(); // 地遁
        List<String> renDun = renDun(); // 人遁
        List<String> shenDun = shenDun(); // 神遁
        List<String> guiDun = guiDun(); // 鬼遁
        List<String> fengDun = fengDun(); // 风遁
        List<String> yunDun = yunDun(); // 云遁
        List<String> longDun = longDun(); // 龙遁
        List<String> huDun = huDun(); // 虎遁

        // 2、整合九遁
        for (int i = 0; i < 9; i++) {
            if (!"".equals(tianDun.get(i))) list.add(tianDun.get(i));
            if (!"".equals(diDun.get(i))) list.add(diDun.get(i));
            if (!"".equals(renDun.get(i))) list.add(renDun.get(i));
            if (!"".equals(shenDun.get(i))) list.add(shenDun.get(i));
            if (!"".equals(guiDun.get(i))) list.add(guiDun.get(i));
            if (!"".equals(fengDun.get(i))) list.add(fengDun.get(i));
            if (!"".equals(yunDun.get(i))) list.add(yunDun.get(i));
            if (!"".equals(longDun.get(i))) list.add(longDun.get(i));
            if (!"".equals(huDun.get(i))) list.add(huDun.get(i));
            map.put(i, list);
            list = new ArrayList<>();
        }

        this.jiuDun = map;

    }

    /**
     * 计算月将、月将神
     */
    private void yueJiang() {

        String monthZhi = getMonthZhi(); // 月支
        this.yueJiang = ZhuanShiJiaQiMenMap.YUE_JIANG.get(monthZhi).get(0); // 月将
        this.yueJiangShen = ZhuanShiJiaQiMenMap.YUE_JIANG.get(monthZhi).get(1); // 月将神

    }

//------------------------------------------------------------------------------------------------------------------------------------

    /**
     * 计算并返回值使
     * <p>
     * <p> 天禽星为值符时：一律用[死门]为值使</p>
     *
     * @return 值使
     */
    private static String zhiShi() {

        return FeiShiJiaQiMenConstant.SI_MEN; // 死门

    }

    /**
     * 计算并返回值使
     * <hr/>
     * <p> 天禽星为值符时：阳遁用[生门]为值使</p>
     * <p> 天禽星为值符时：阴遁用[死门]为值使</p>
     *
     * @param yinYangDun 阴阳遁
     * @return 值使
     * @deprecated 使用zhiShi()
     */
    @Deprecated
    private static String zhiShi2(String yinYangDun) {

        // 阳遁用生门，阴遁用死门
        if (FeiShiJiaQiMenConstant.YANG_DUN.equals(yinYangDun)) {
            return FeiShiJiaQiMenConstant.SHENG_MEN; // 生门
        } else {
            return FeiShiJiaQiMenConstant.SI_MEN; // 死门
        }

    }

    /**
     * 计算并返回值使
     * <hr/>
     * <p>天禽星为值符时：（冬至、小寒、大寒）三个节气，用[休门]为值使</p>
     * <p>天禽星为值符时：（立春，雨水，惊蛰）三个节气，用[生门]为值使</p>
     * <p>天禽星为值符时：（春分、清明、谷雨）三个节气，用[伤门]为值使</p>
     * <p>天禽星为值符时：（立夏、小满、芒种）三个节气，用[杜门]为值使</p>
     * <p>天禽星为值符时：（夏至、小暑、大暑）三个节气，用[景门]为值使</p>
     * <p>天禽星为值符时：（立秋、处暑、白露）三个节气，用[死门]为值使</p>
     * <p>天禽星为值符时：（秋分、寒露、霜降）三个节气，用[惊门]为值使</p>
     * <p>天禽星为值符时：（立冬、小雪、大雪）三个节气，用[开门]为值使</p>
     *
     * @param jieQi 节气
     * @return 值使
     * @deprecated 使用zhiShi()
     */
    @Deprecated
    private static String zhiShi3(String jieQi) {

        Map<Integer, List<String>> isBaMen = ZhuanShiJiaQiMenMap.IS_BA_MEN; // 根据二十四节气获取八门

        // 根据二十四节气判断八门
        for (int i = 0; i < isBaMen.size(); i++) {
            for (int j = 0; j < isBaMen.get(i).size(); j++) {
                String s = isBaMen.get(i).get(j);
                if (s.equals(jieQi)) {
                    switch (i) {
                        case 0:
                            return FeiShiJiaQiMenConstant.XIU_MEN; // 休门
                        case 1:
                            return FeiShiJiaQiMenConstant.SHENG_MEN; // 生门
                        case 2:
                            return FeiShiJiaQiMenConstant.SHANG_MEN; // 伤门
                        case 3:
                            return FeiShiJiaQiMenConstant.DU_MEN; // 杜门
                        case 4:
                            return FeiShiJiaQiMenConstant.JING_MEN_1; // 景门
                        case 5:
                            return FeiShiJiaQiMenConstant.SI_MEN; // 死门
                        case 6:
                            return FeiShiJiaQiMenConstant.JING_MEN_2; // 惊门
                        case 7:
                            return FeiShiJiaQiMenConstant.KAI_MEN; // 开门
                    }
                }
            }
        }

        return "";

    }

    /**
     * 计算并返回八门静应、动应
     *
     * @param menDongOrJing 八门静应\八门动应
     * @return [八门静应\八门动应]信息
     */
    private List<String> men(Map<List<String>, String> menDongOrJing) {

        String[] baMenInitial = ZhuanShiJiaQiMenMap.BA_MEN_INITIAL;// 八门初始位置
        List<String> renPan = getRenPan(); // 人盘八门

        // 组合[门+门]
        List<String> menData = new ArrayList<>(); // 存放[门+门]信息
        for (int i = 0; i < renPan.size(); i++) {
            if (!"".equals(renPan.get(i)) && i != 4) {
                String oldMen = renPan.get(i);
                String newMen = baMenInitial[i];
                List<String> men = CommonUtil.addList(oldMen, newMen);
                menData.add(oldMen + "+" + newMen + "：" + menDongOrJing.get(men));
            } else {
                menData.add(""); // 置空中五宫数据
            }
        }

        return menData;

    }

    /**
     * 计算并返回天遁
     */
    private List<String> tianDun() {

        /*
            天盘[丙奇(月奇)]加地盘[六丁]合人盘[开门、休门、生门]。即【丙+丁+开门、休门、生门】。
         */

        List<String> list = CommonUtil.addListEmpty(9);

        for (int i = 0; i < 9; i++) {
            String to = getTianPanQiYiToTianQin().get(i); // 每一宫位中的天盘旋转后九星所携带的三奇六仪，只包含[天禽星]携带的三奇六仪（1~9宫）
            String ex = getTianPanQiYiExTianQin().get(i); // 每一宫位中的天盘旋转后九星所携带的三奇六仪，不包含[天禽星]携带的三奇六仪（1~9宫）
            String diPan = getDiPan().get(i); // 每一宫位中的奇仪
            String renPan = getRenPan().get(i); // 每一宫位中的门
            // 判断宫位信息是否符合→ 天盘[丙奇(月奇)]加地盘[六丁]合人盘[开门、休门、生门]。
            if ((ZhuanShiJiaQiMenConstant.BING_GAN.equals(to) || ZhuanShiJiaQiMenConstant.BING_GAN.equals(ex)) &&
                    ZhuanShiJiaQiMenConstant.DING_GAN.equals(diPan) &&
                    (ZhuanShiJiaQiMenConstant.KAI_MEN.equals(renPan) || ZhuanShiJiaQiMenConstant.XIU_MEN.equals(renPan) || ZhuanShiJiaQiMenConstant.SHENG_MEN.equals(renPan))) {
                list.set(i, ZhuanShiJiaQiMenConstant.TIAN_DUN);
            }
        }

        return list;

    }

    /**
     * 计算并返回地遁
     */
    private List<String> diDun() {

        /*
            天盘[乙奇(日奇)]加地盘[六己]合人盘[开门、休门、生门]。即【乙+己+开门、休门、生门】。
         */

        List<String> list = CommonUtil.addListEmpty(9);

        for (int i = 0; i < 9; i++) {
            String to = getTianPanQiYiToTianQin().get(i); // 每一宫位中的天盘旋转后九星所携带的三奇六仪，只包含[天禽星]携带的三奇六仪（1~9宫）
            String ex = getTianPanQiYiExTianQin().get(i); // 每一宫位中的天盘旋转后九星所携带的三奇六仪，不包含[天禽星]携带的三奇六仪（1~9宫）
            String diPan = getDiPan().get(i); // 每一宫位中的奇仪
            String renPan = getRenPan().get(i); // 每一宫位中的门
            // 判断宫位信息是否符合→ 天盘[乙奇(日奇)]加地盘[六己]合人盘[开门、休门、生门]。
            if ((ZhuanShiJiaQiMenConstant.YI_GAN.equals(to) || ZhuanShiJiaQiMenConstant.YI_GAN.equals(ex)) &&
                    ZhuanShiJiaQiMenConstant.JI_GAN.equals(diPan) &&
                    (ZhuanShiJiaQiMenConstant.KAI_MEN.equals(renPan) || ZhuanShiJiaQiMenConstant.XIU_MEN.equals(renPan) || ZhuanShiJiaQiMenConstant.SHENG_MEN.equals(renPan))) {
                list.set(i, ZhuanShiJiaQiMenConstant.DI_DUN);
            }
        }

        return list;

    }

    /**
     * 计算并返回人遁
     */
    private List<String> renDun() {

        /*
            天盘[丁奇(星奇)]加神盘[太阴]合人盘[休门]。即【丁+太阴+休门】。
         */

        List<String> list = CommonUtil.addListEmpty(9);

        for (int i = 0; i < 9; i++) {
            String to = getTianPanQiYiToTianQin().get(i); // 每一宫位中的天盘旋转后九星所携带的三奇六仪，只包含[天禽星]携带的三奇六仪（1~9宫）
            String ex = getTianPanQiYiExTianQin().get(i); // 每一宫位中的天盘旋转后九星所携带的三奇六仪，不包含[天禽星]携带的三奇六仪（1~9宫）
            String shenPan = getShenPan().get(i); // 每一宫位中的神
            String renPan = getRenPan().get(i); // 每一宫位中的门
            // 判断宫位信息是否符合→ 天盘[丁奇(星奇)]加神盘[太阴]合人盘[休门]。
            if ((ZhuanShiJiaQiMenConstant.DING_GAN.equals(to) || ZhuanShiJiaQiMenConstant.DING_GAN.equals(ex)) &&
                    ZhuanShiJiaQiMenConstant.TAI_YIN.equals(shenPan) && ZhuanShiJiaQiMenConstant.XIU_MEN.equals(renPan)) {
                list.set(i, ZhuanShiJiaQiMenConstant.REN_DUN);
            }
        }

        return list;

    }

    /**
     * 计算并返回神遁
     */
    private List<String> shenDun() {

        /*
            天盘[丙奇(月奇)]加神盘[九天]合人盘[生门]。即【丙+九天+生门】。
         */

        List<String> list = CommonUtil.addListEmpty(9);

        for (int i = 0; i < 9; i++) {
            String to = getTianPanQiYiToTianQin().get(i); // 每一宫位中的天盘旋转后九星所携带的三奇六仪，只包含[天禽星]携带的三奇六仪（1~9宫）
            String ex = getTianPanQiYiExTianQin().get(i); // 每一宫位中的天盘旋转后九星所携带的三奇六仪，不包含[天禽星]携带的三奇六仪（1~9宫）
            String shenPan = getShenPan().get(i); // 每一宫位中的神
            String renPan = getRenPan().get(i); // 每一宫位中的门
            // 判断宫位信息是否符合→ 天盘[丙奇(月奇)]加神盘[九天]合人盘[生门]。
            if ((ZhuanShiJiaQiMenConstant.BING_GAN.equals(to) || ZhuanShiJiaQiMenConstant.BING_GAN.equals(ex)) &&
                    ZhuanShiJiaQiMenConstant.JIU_TIAN.equals(shenPan) && ZhuanShiJiaQiMenConstant.SHENG_MEN.equals(renPan)) {
                list.set(i, ZhuanShiJiaQiMenConstant.SHEN_DUN);
            }
        }

        return list;

    }

    /**
     * 计算并返回鬼遁
     */
    private List<String> guiDun() {

        /*
            天盘[丁奇(星奇)]加神盘[九地]合人盘[杜门、开门]。即【丙+九天+生门】。
         */

        List<String> list = CommonUtil.addListEmpty(9);

        for (int i = 0; i < 9; i++) {
            String to = getTianPanQiYiToTianQin().get(i); // 每一宫位中的天盘旋转后九星所携带的三奇六仪，只包含[天禽星]携带的三奇六仪（1~9宫）
            String ex = getTianPanQiYiExTianQin().get(i); // 每一宫位中的天盘旋转后九星所携带的三奇六仪，不包含[天禽星]携带的三奇六仪（1~9宫）
            String shenPan = getShenPan().get(i); // 每一宫位中的神
            String renPan = getRenPan().get(i); // 每一宫位中的门
            // 判断宫位信息是否符合→ 天盘[丁奇(星奇)]加神盘[九地]合人盘[杜门、开门]。
            if ((ZhuanShiJiaQiMenConstant.DING_GAN.equals(to) || ZhuanShiJiaQiMenConstant.DING_GAN.equals(ex)) &&
                    ZhuanShiJiaQiMenConstant.JIU_DI.equals(shenPan) &&
                    (ZhuanShiJiaQiMenConstant.DU_MEN.equals(renPan) || ZhuanShiJiaQiMenConstant.KAI_MEN.equals(renPan))) {
                list.set(i, ZhuanShiJiaQiMenConstant.GUI_DUN);
            }
        }

        return list;

    }

    /**
     * 计算并返回风遁
     */
    private List<String> fengDun() {

        /*
            天盘[乙奇(日奇)]加人盘[开门、休门、生门]临[巽四宫]。即【乙+巽四宫+开门、休门、生门】。
         */

        List<String> list = CommonUtil.addListEmpty(9);

        // 1、获取巽四宫信息
        int gongWei = 3; // 巽四宫对应索引值为3
        String to = getTianPanQiYiToTianQin().get(gongWei); // 巽四宫天盘旋转后九星所携带的三奇六仪，只包含[天禽星]携带的三奇六仪（1~9宫）
        String ex = getTianPanQiYiExTianQin().get(gongWei); // 巽四宫天盘旋转后九星所携带的三奇六仪，不包含[天禽星]携带的三奇六仪（1~9宫）
        String renPan = getRenPan().get(gongWei); // 巽四宫中的门

        // 2、判断巽四宫信息是否符合→ 天盘[乙奇(日奇)]加人盘[开门、休门、生门]临[巽四宫]。
        if ((ZhuanShiJiaQiMenConstant.YI_GAN.equals(to) || ZhuanShiJiaQiMenConstant.YI_GAN.equals(ex)) &&
                (ZhuanShiJiaQiMenConstant.KAI_MEN.equals(renPan) || ZhuanShiJiaQiMenConstant.XIU_MEN.equals(renPan) || ZhuanShiJiaQiMenConstant.SHENG_MEN.equals(renPan))) {
            list.set(gongWei, ZhuanShiJiaQiMenConstant.FENG_DUN);
        }

        return list;

    }

    /**
     * 计算并返回云遁
     */
    private List<String> yunDun() {

        /*
            天盘[乙奇(日奇)]加地盘[六辛]合人盘[开门、休门、生门]。即【乙+辛+开门、休门、生门】。
         */

        List<String> list = CommonUtil.addListEmpty(9);

        for (int i = 0; i < 9; i++) {
            String to = getTianPanQiYiToTianQin().get(i); // 每一宫位中的天盘旋转后九星所携带的三奇六仪，只包含[天禽星]携带的三奇六仪（1~9宫）
            String ex = getTianPanQiYiExTianQin().get(i); // 每一宫位中的天盘旋转后九星所携带的三奇六仪，不包含[天禽星]携带的三奇六仪（1~9宫）
            String diPan = getDiPan().get(i); // 每一宫位中的奇仪
            String renPan = getRenPan().get(i); // 每一宫位中的门
            // 宫位信息是否符合→ 天盘[乙奇(日奇)]加地盘[六辛]合人盘[开门、休门、生门]。
            if ((ZhuanShiJiaQiMenConstant.YI_GAN.equals(to) || ZhuanShiJiaQiMenConstant.YI_GAN.equals(ex)) &&
                    ZhuanShiJiaQiMenConstant.XIN_GAN.equals(diPan) &&
                    (ZhuanShiJiaQiMenConstant.KAI_MEN.equals(renPan) || ZhuanShiJiaQiMenConstant.XIU_MEN.equals(renPan) || ZhuanShiJiaQiMenConstant.SHENG_MEN.equals(renPan))) {
                list.set(i, ZhuanShiJiaQiMenConstant.YUN_DUN);
            }
        }

        return list;

    }

    /**
     * 计算并返回龙遁
     */
    private List<String> longDun() {

        /*
            1、天盘[乙奇(日奇)]加人盘[开门、休门、生门]临[坎一宫]。即【乙+坎一宫+开门、休门、生门】
            2、天盘[乙奇(日奇)]加地盘[六癸]合人盘[开门、休门、生门]。即【乙+癸+开门、休门、生门】
         */

        List<String> list = CommonUtil.addListEmpty(9);

        // 1、获取坎一宫信息
        int gongWei = 0; // 坎一宫对应索引值为0
        String to = getTianPanQiYiToTianQin().get(gongWei); // 每一宫位中的天盘旋转后九星所携带的三奇六仪，只包含[天禽星]携带的三奇六仪（1~9宫）
        String ex = getTianPanQiYiExTianQin().get(gongWei); // 每一宫位中的天盘旋转后九星所携带的三奇六仪，不包含[天禽星]携带的三奇六仪（1~9宫）
        String renPan = getRenPan().get(gongWei); // 坎一宫门

        // 2、判断坎一宫信息是否符合→ 天盘[乙奇(日奇)]加人盘[开门、休门、生门]临[坎一宫]。
        if ((ZhuanShiJiaQiMenConstant.YI_GAN.equals(to) || ZhuanShiJiaQiMenConstant.YI_GAN.equals(ex)) &&
                (ZhuanShiJiaQiMenConstant.KAI_MEN.equals(renPan) || ZhuanShiJiaQiMenConstant.XIU_MEN.equals(renPan) || ZhuanShiJiaQiMenConstant.SHENG_MEN.equals(renPan))) {
            list.set(gongWei, ZhuanShiJiaQiMenConstant.LONG_DUN);
        } else {
            // 2.1、判断1~9宫信息
            for (int i = 0; i < 9; i++) {
                String to2 = getTianPanQiYiToTianQin().get(i); // 每一宫位中的天盘旋转后九星所携带的三奇六仪，只包含[天禽星]携带的三奇六仪（1~9宫）
                String ex2 = getTianPanQiYiExTianQin().get(i); // 每一宫位中的天盘旋转后九星所携带的三奇六仪，不包含[天禽星]携带的三奇六仪（1~9宫）
                String diPan2 = getDiPan().get(i); // 每一宫位中的奇仪
                String renPan2 = getRenPan().get(i); // 每一宫位中的八门
                // 2.2、判断宫位信息是否符合→ 天盘[乙奇(日奇)]加地盘[六癸]合人盘[开门、休门、生门]。
                if ((ZhuanShiJiaQiMenConstant.YI_GAN.equals(to2) || ZhuanShiJiaQiMenConstant.YI_GAN.equals(ex2)) &&
                        ZhuanShiJiaQiMenConstant.GUI_GAN.equals(diPan2) &&
                        (ZhuanShiJiaQiMenConstant.KAI_MEN.equals(renPan2) || ZhuanShiJiaQiMenConstant.XIU_MEN.equals(renPan2) || ZhuanShiJiaQiMenConstant.SHENG_MEN.equals(renPan2))) {
                    list.set(i, ZhuanShiJiaQiMenConstant.LONG_DUN);
                }
            }
        }

        return list;

    }

    /**
     * 计算并返回虎遁
     */
    private List<String> huDun() {

        /*
            1、天盘[六庚]加人盘[开门]临[兑七宫]。即【庚+兑七宫+开门】
            2、天盘[乙奇(日奇)]加地盘[六辛]合人盘[休门、生门]临[艮八宫]。即【乙+辛+艮八宫+休门、生门】
         */

        List<String> list = CommonUtil.addListEmpty(9);


        // 1、获取兑七宫信息
        int gongWei = 6; // 兑七宫对应索引值为6
        String to = getTianPanQiYiToTianQin().get(gongWei); // 每一宫位中的天盘旋转后九星所携带的三奇六仪，只包含[天禽星]携带的三奇六仪（1~9宫）
        String ex = getTianPanQiYiExTianQin().get(gongWei); // 每一宫位中的天盘旋转后九星所携带的三奇六仪，不包含[天禽星]携带的三奇六仪（1~9宫）
        String renPan = getRenPan().get(gongWei); // 兑七宫门

        // 2、获取艮八宫信息
        int gongWei2 = 7; // 艮八宫对应索引值为7
        String to2 = getTianPanQiYiToTianQin().get(gongWei); // 每一宫位中的天盘旋转后九星所携带的三奇六仪，只包含[天禽星]携带的三奇六仪（1~9宫）
        String ex2 = getTianPanQiYiExTianQin().get(gongWei); // 每一宫位中的天盘旋转后九星所携带的三奇六仪，不包含[天禽星]携带的三奇六仪（1~9宫）
        String diPan2 = getDiPan().get(gongWei2); // 艮八宫奇仪
        String renPan2 = getRenPan().get(gongWei2); // 艮八宫门

        // 3、判断兑七宫信息是否符合→ 天盘[六庚]加人盘[开门]临[兑七宫]。
        if ((ZhuanShiJiaQiMenConstant.GENG_GAN.equals(to) || ZhuanShiJiaQiMenConstant.GENG_GAN.equals(ex)) && ZhuanShiJiaQiMenConstant.KAI_MEN.equals(renPan)) {
            list.set(gongWei, ZhuanShiJiaQiMenConstant.HU_DUN);
        } else {
            // 3.1、判断艮八宫信息是否符合→ 天盘[乙奇(日奇)]加地盘[六辛]合人盘[休门、生门]临[艮八宫]
            if ((ZhuanShiJiaQiMenConstant.YI_GAN.equals(to2) || ZhuanShiJiaQiMenConstant.YI_GAN.equals(ex2)) &&
                    ZhuanShiJiaQiMenConstant.XIN_GAN.equals(diPan2) &&
                    (ZhuanShiJiaQiMenConstant.XIU_MEN.equals(renPan2) || ZhuanShiJiaQiMenConstant.SHENG_MEN.equals(renPan2))) {
                list.set(gongWei, ZhuanShiJiaQiMenConstant.HU_DUN);
            }
        }

        return list;

    }

    /**
     * 获取公历日期
     *
     * @return 公历日期（如：2023年6月15日12时）
     */
    public String getSolarStr() {

        return ZhuanShiJiaQiMenUtil.getSolarStr(getSolar());

    }

    /**
     * 获取农历日期
     *
     * @return 农历日期（如：二〇二三年四月廿八午时）
     */
    public String getLunarStr() {

        return ZhuanShiJiaQiMenUtil.getLunarStr(getLunar());

    }

    @Override
    public String toString() {

        StringBuilder s = new StringBuilder();

        s.append("公历").append(getSolarStr());
        s.append("   ");
        s.append("农历").append(getLunarStr());
        s.append("   ");
        s.append("星期:").append(getWeek());
        s.append("   ");
        s.append("八字:").append(getBaZi());
        s.append("   ");
        s.append("八字五行:").append(getBaZiWuXing());
        s.append("   ");
        s.append("八字纳音:").append(getBaZiNaYin());
        s.append("   ");
        s.append("八字旬空:").append(getBaZiXunKong());
        s.append("   ");
        s.append("符头:").append(getFuTou());
        s.append("   ");
        s.append("节气:").append(getJieQi()).append(getSanYuan());
        s.append("   ");
        s.append("局数:").append(getYinYangDun()).append(getJuShu()).append("局");
        s.append("   ");
        s.append("旬首:").append(getXunShou());
        s.append("   ");
        s.append("值符:").append(getZhiFu());
        s.append("   ");
        s.append("值使:").append(getZhiShi());
        s.append("   ");
        s.append("天乙:").append(getTianYi());
        s.append("   ");
        s.append("地乙:").append(getDiYi());
        s.append("   ");
        s.append("太乙:").append(getZhiShi());
        s.append("   ");
        s.append("地盘:").append(getDiPan());
        s.append("   ");
        s.append("天盘:").append(getTianPan());
        s.append("   ");
        s.append("人盘:").append(getRenPan());
        s.append("   ");
        s.append("神盘:").append(getShenPan());
        s.append("   ");
        s.append("六仪击刑:").append(getLiuYiJiXing());
        s.append("   ");
        s.append("奇仪入墓:").append(getQiYiRuMu());
        s.append("   ");
        s.append("月将:").append(getYueJiang());
        s.append("   ");
        s.append("月将神:").append(getYueJiangShen());

        return s.toString();

    }


}
